home *** CD-ROM | disk | FTP | other *** search
/ Aminet 40 / Aminet 40 (2000)(Schatztruhe)[!][Dec 2000].iso / Aminet / dev / lang / Python16_Src.lha / Python16_Source / Python / getargs.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-09-10  |  28.1 KB  |  1,312 lines
  1. /* New getargs implementation */
  2.  
  3. /* XXX There are several unchecked sprintf or strcat calls in this file.
  4.    XXX The only way these can become a danger is if some C code in the
  5.    XXX Python source (or in an extension) uses ridiculously long names
  6.    XXX or riduculously deep nesting in format strings. */
  7.  
  8. #include "Python.h"
  9.  
  10. #include <ctype.h>
  11.  
  12. #ifdef HAVE_LIMITS_H
  13. #include <limits.h>
  14. #endif
  15.  
  16. int PyArg_Parse Py_PROTO((PyObject *, char *, ...));
  17. int PyArg_ParseTuple Py_PROTO((PyObject *, char *, ...));
  18. int PyArg_VaParse Py_PROTO((PyObject *, char *, va_list));
  19.  
  20. int PyArg_ParseTupleAndKeywords Py_PROTO((PyObject *, PyObject *,
  21.                        char *, char **, ...));
  22.  
  23. /* Forward */
  24. static int vgetargs1 Py_PROTO((PyObject *, char *, va_list *, int));
  25. static void seterror Py_PROTO((int, char *, int *, char *, char *));
  26. static char *convertitem Py_PROTO((PyObject *, char **, va_list *,
  27.                    int *, char *));
  28. static char *converttuple Py_PROTO((PyObject *, char **, va_list *,
  29.                  int *, char *, int));
  30. static char *convertsimple Py_PROTO((PyObject *, char **, va_list *, char *));
  31. static char *convertsimple1 Py_PROTO((PyObject *, char **, va_list *));
  32.  
  33. static int vgetargskeywords Py_PROTO((PyObject *, PyObject *,
  34.                    char *, char **, va_list *));
  35. static char *skipitem Py_PROTO((char **, va_list *));
  36.  
  37. #ifdef HAVE_STDARG_PROTOTYPES
  38. /* VARARGS2 */
  39. int PyArg_Parse(PyObject *args, char *format, ...)
  40. #else
  41. /* VARARGS */
  42. int PyArg_Parse(va_alist) va_dcl
  43. #endif
  44. {
  45.     int retval;
  46.     va_list va;
  47. #ifdef HAVE_STDARG_PROTOTYPES
  48.     
  49.     va_start(va, format);
  50. #else
  51.     PyObject *args;
  52.     char *format;
  53.     
  54.     va_start(va);
  55.     args = va_arg(va, PyObject *);
  56.     format = va_arg(va, char *);
  57. #endif
  58.     retval = vgetargs1(args, format, &va, 1);
  59.     va_end(va);
  60.     return retval;
  61. }
  62.  
  63.  
  64. #ifdef HAVE_STDARG_PROTOTYPES
  65. /* VARARGS2 */
  66. int PyArg_ParseTuple(PyObject *args, char *format, ...)
  67. #else
  68. /* VARARGS */
  69. int PyArg_ParseTuple(va_alist) va_dcl
  70. #endif
  71. {
  72.     int retval;
  73.     va_list va;
  74. #ifdef HAVE_STDARG_PROTOTYPES
  75.     
  76.     va_start(va, format);
  77. #else
  78.     PyObject *args;
  79.     char *format;
  80.     
  81.     va_start(va);
  82.     args = va_arg(va, PyObject *);
  83.     format = va_arg(va, char *);
  84. #endif
  85.     retval = vgetargs1(args, format, &va, 0);
  86.     va_end(va);
  87.     return retval;
  88. }
  89.  
  90.  
  91. int
  92. PyArg_VaParse(args, format, va)
  93.     PyObject *args;
  94.     char *format;
  95.     va_list va;
  96. {
  97.     va_list lva;
  98.  
  99. #ifdef VA_LIST_IS_ARRAY
  100.     memcpy(lva, va, sizeof(va_list));
  101. #else
  102.     lva = va;
  103. #endif
  104.  
  105.     return vgetargs1(args, format, &lva, 0);
  106. }
  107.  
  108.  
  109. static int
  110. vgetargs1(args, format, p_va, compat)
  111.     PyObject *args;
  112.     char *format;
  113.     va_list *p_va;
  114.     int compat;
  115. {
  116.     char msgbuf[256];
  117.     int levels[32];
  118.     char *fname = NULL;
  119.     char *message = NULL;
  120.     int min = -1;
  121.     int max = 0;
  122.     int level = 0;
  123.     char *formatsave = format;
  124.     int i, len;
  125.     char *msg;
  126.     
  127.     for (;;) {
  128.         int c = *format++;
  129.         if (c == '(' /* ')' */) {
  130.             if (level == 0)
  131.                 max++;
  132.             level++;
  133.         }
  134.         else if (/* '(' */ c == ')') {
  135.             if (level == 0)
  136.                 Py_FatalError(/* '(' */
  137.                       "excess ')' in getargs format");
  138.             else
  139.                 level--;
  140.         }
  141.         else if (c == '\0')
  142.             break;
  143.         else if (c == ':') {
  144.             fname = format;
  145.             break;
  146.         }
  147.         else if (c == ';') {
  148.             message = format;
  149.             break;
  150.         }
  151.         else if (level != 0)
  152.             ; /* Pass */
  153.         else if (c == 'e')
  154.             ; /* Pass */
  155.         else if (isalpha(c))
  156.             max++;
  157.         else if (c == '|')
  158.             min = max;
  159.     }
  160.     
  161.     if (level != 0)
  162.         Py_FatalError(/* '(' */ "missing ')' in getargs format");
  163.     
  164.     if (min < 0)
  165.         min = max;
  166.     
  167.     format = formatsave;
  168.     
  169.     if (compat) {
  170.         if (max == 0) {
  171.             if (args == NULL)
  172.                 return 1;
  173.             sprintf(msgbuf, "%s requires no arguments",
  174.                 fname==NULL ? "function" : fname);
  175.             PyErr_SetString(PyExc_TypeError, msgbuf);
  176.             return 0;
  177.         }
  178.         else if (min == 1 && max == 1) {
  179.             if (args == NULL) {
  180.                 sprintf(msgbuf,
  181.                     "%s requires at least one argument",
  182.                     fname==NULL ? "function" : fname);
  183.                 PyErr_SetString(PyExc_TypeError, msgbuf);
  184.                 return 0;
  185.             }
  186.             msg = convertitem(args, &format, p_va, levels, msgbuf);
  187.             if (msg == NULL)
  188.                 return 1;
  189.             seterror(levels[0], msg, levels+1, fname, message);
  190.             return 0;
  191.         }
  192.         else {
  193.             PyErr_SetString(PyExc_SystemError,
  194.                 "old style getargs format uses new features");
  195.             return 0;
  196.         }
  197.     }
  198.     
  199.     if (!PyTuple_Check(args)) {
  200.         PyErr_SetString(PyExc_SystemError,
  201.             "new style getargs format but argument is not a tuple");
  202.         return 0;
  203.     }
  204.     
  205.     len = PyTuple_Size(args);
  206.     
  207.     if (len < min || max < len) {
  208.         if (message == NULL) {
  209.             sprintf(msgbuf,
  210.                 "%s requires %s %d argument%s; %d given",
  211.                 fname==NULL ? "function" : fname,
  212.                 min==max ? "exactly"
  213.                          : len < min ? "at least" : "at most",
  214.                 len < min ? min : max,
  215.                 (len < min ? min : max) == 1 ? "" : "s",
  216.                 len);
  217.             message = msgbuf;
  218.         }
  219.         PyErr_SetString(PyExc_TypeError, message);
  220.         return 0;
  221.     }
  222.     
  223.     for (i = 0; i < len; i++) {
  224.         if (*format == '|')
  225.             format++;
  226.         msg = convertitem(PyTuple_GetItem(args, i), &format, p_va,
  227.                  levels, msgbuf);
  228.         if (msg) {
  229.             seterror(i+1, msg, levels, fname, message);
  230.             return 0;
  231.         }
  232.     }
  233.  
  234.     if (*format != '\0' && !isalpha((int)(*format)) &&
  235.         *format != '(' &&
  236.         *format != '|' && *format != ':' && *format != ';') {
  237.         PyErr_Format(PyExc_SystemError,
  238.                  "bad format string: %.200s", formatsave);
  239.         return 0;
  240.     }
  241.     
  242.     return 1;
  243. }
  244.  
  245.  
  246.  
  247. static void
  248. seterror(iarg, msg, levels, fname, message)
  249.     int iarg;
  250.     char *msg;
  251.     int *levels;
  252.     char *fname;
  253.     char *message;
  254. {
  255.     char buf[256];
  256.     int i;
  257.     char *p = buf;
  258.  
  259.     if (PyErr_Occurred())
  260.         return;
  261.     if (iarg == 0 && message == NULL)
  262.         message = msg;
  263.     else if (message == NULL) {
  264.         if (fname != NULL) {
  265.             sprintf(p, "%s, ", fname);
  266.             p += strlen(p);
  267.         }
  268.         sprintf(p, "argument %d", iarg);
  269.         i = 0;
  270.         p += strlen(p);
  271.         while (levels[i] > 0) {
  272.             sprintf(p, ", item %d", levels[i]-1);
  273.             p += strlen(p);
  274.             i++;
  275.         }
  276.         sprintf(p, ": expected %s found", msg);
  277.         message = buf;
  278.     }
  279.     PyErr_SetString(PyExc_TypeError, message);
  280. }
  281.  
  282.  
  283. /* Convert a tuple argument.
  284.    On entry, *p_format points to the character _after_ the opening '('.
  285.    On successful exit, *p_format points to the closing ')'.
  286.    If successful:
  287.       *p_format and *p_va are updated,
  288.       *levels and *msgbuf are untouched,
  289.       and NULL is returned.
  290.    If the argument is invalid:
  291.       *p_format is unchanged,
  292.       *p_va is undefined,
  293.       *levels is a 0-terminated list of item numbers,
  294.       *msgbuf contains an error message, whose format is:
  295.          "<typename1>, <typename2>", where:
  296.             <typename1> is the name of the expected type, and
  297.             <typename2> is the name of the actual type,
  298.          (so you can surround it by "expected ... found"),
  299.       and msgbuf is returned.
  300. */
  301.  
  302. static char *
  303. converttuple(arg, p_format, p_va, levels, msgbuf, toplevel)
  304.     PyObject *arg;
  305.     char **p_format;
  306.     va_list *p_va;
  307.     int *levels;
  308.     char *msgbuf;
  309.     int toplevel;
  310. {
  311.     int level = 0;
  312.     int n = 0;
  313.     char *format = *p_format;
  314.     int i;
  315.     
  316.     for (;;) {
  317.         int c = *format++;
  318.         if (c == '(') {
  319.             if (level == 0)
  320.                 n++;
  321.             level++;
  322.         }
  323.         else if (c == ')') {
  324.             if (level == 0)
  325.                 break;
  326.             level--;
  327.         }
  328.         else if (c == ':' || c == ';' || c == '\0')
  329.             break;
  330.         else if (level == 0 && isalpha(c))
  331.             n++;
  332.     }
  333.     
  334.     if (!PySequence_Check(arg)) {
  335.         levels[0] = 0;
  336.         sprintf(msgbuf,
  337.             toplevel ? "%d arguments, %s" : "%d-sequence, %s",
  338.             n, arg == Py_None ? "None" : arg->ob_type->tp_name);
  339.         return msgbuf;
  340.     }
  341.     
  342.     if ((i = PySequence_Length(arg)) != n) {
  343.         levels[0] = 0;
  344.         sprintf(msgbuf,
  345.             toplevel ? "%d arguments, %d" : "%d-sequence, %d-sequence",
  346.             n, i);
  347.         return msgbuf;
  348.     }
  349.     
  350.     format = *p_format;
  351.     for (i = 0; i < n; i++) {
  352.         char *msg;
  353.         PyObject *item;
  354.         item = PySequence_GetItem(arg, i);
  355.         msg = convertitem(item, &format, p_va, levels+1, msgbuf);
  356.         /* PySequence_GetItem calls tp->sq_item, which INCREFs */
  357.         Py_XDECREF(item);
  358.         if (msg != NULL) {
  359.             levels[0] = i+1;
  360.             return msg;
  361.         }
  362.     }
  363.     
  364.     *p_format = format;
  365.     return NULL;
  366. }
  367.  
  368.  
  369. /* Convert a single item. */
  370.  
  371. static char *
  372. convertitem(arg, p_format, p_va, levels, msgbuf)
  373.     PyObject *arg;
  374.     char **p_format;
  375.     va_list *p_va;
  376.     int *levels;
  377.     char *msgbuf;
  378. {
  379.     char *msg;
  380.     char *format = *p_format;
  381.     
  382.     if (*format == '(' /* ')' */) {
  383.         format++;
  384.         msg = converttuple(arg, &format, p_va, levels, msgbuf, 0);
  385.         if (msg == NULL)
  386.             format++;
  387.     }
  388.     else {
  389.         msg = convertsimple(arg, &format, p_va, msgbuf);
  390.         if (msg != NULL)
  391.             levels[0] = 0;
  392.     }
  393.     if (msg == NULL)
  394.         *p_format = format;
  395.     return msg;
  396. }
  397.  
  398.  
  399. /* Convert a non-tuple argument.  Adds to convertsimple1 functionality
  400.    by appending ", <actual argument type>" to error message. */
  401.  
  402. static char *
  403. convertsimple(arg, p_format, p_va, msgbuf)
  404.     PyObject *arg;
  405.     char **p_format;
  406.     va_list *p_va;
  407.     char *msgbuf;
  408. {
  409.     char *msg = convertsimple1(arg, p_format, p_va);
  410.     if (msg != NULL) {
  411.         sprintf(msgbuf, "%.50s, %.50s", msg,
  412.             arg == Py_None ? "None" : arg->ob_type->tp_name);
  413.         msg = msgbuf;
  414.     }
  415.     return msg;
  416. }
  417.  
  418.  
  419. /* Internal API needed by convertsimple1(): */
  420. extern 
  421. PyObject *_PyUnicode_AsDefaultEncodedString(PyObject *unicode,
  422.                   const char *errors);
  423.  
  424. /* Convert a non-tuple argument.  Return NULL if conversion went OK,
  425.    or a string representing the expected type if the conversion failed.
  426.    When failing, an exception may or may not have been raised.
  427.    Don't call if a tuple is expected. */
  428.  
  429. static char *
  430. convertsimple1(arg, p_format, p_va)
  431.     PyObject *arg;
  432.     char **p_format;
  433.     va_list *p_va;
  434. {
  435.     char *format = *p_format;
  436.     char c = *format++;
  437.     
  438.     switch (c) {
  439.     
  440.     case 'b': /* unsigned byte -- very short int */
  441.         {
  442.             char *p = va_arg(*p_va, char *);
  443.             long ival = PyInt_AsLong(arg);
  444.             if (ival == -1 && PyErr_Occurred())
  445.                 return "integer<b>";
  446.             else if (ival < 0) {
  447.                 PyErr_SetString(PyExc_OverflowError,
  448.                     "unsigned byte integer is less than minimum");
  449.                 return "integer<b>";
  450.             }
  451.             else if (ival > UCHAR_MAX) {
  452.                 PyErr_SetString(PyExc_OverflowError,
  453.                     "unsigned byte integer is greater than maximum");
  454.                 return "integer<b>";
  455.             }
  456.             else
  457.                 *p = (unsigned char) ival;
  458.             break;
  459.         }
  460.     
  461.     case 'h': /* signed short int */
  462.         {
  463.             short *p = va_arg(*p_va, short *);
  464.             long ival = PyInt_AsLong(arg);
  465.             if (ival == -1 && PyErr_Occurred())
  466.                 return "integer<h>";
  467.             else if (ival < SHRT_MIN) {
  468.                 PyErr_SetString(PyExc_OverflowError,
  469.                     "signed short integer is less than minimum");
  470.                 return "integer<h>";
  471.             }
  472.             else if (ival > SHRT_MAX) {
  473.                 PyErr_SetString(PyExc_OverflowError,
  474.                   "signed short integer is greater than maximum");
  475.                 return "integer<h>";
  476.             }
  477.             else
  478.                 *p = (short) ival;
  479.             break;
  480.         }
  481.     
  482.     case 'i': /* signed int */
  483.         {
  484.             int *p = va_arg(*p_va, int *);
  485.             long ival = PyInt_AsLong(arg);
  486.             if (ival == -1 && PyErr_Occurred())
  487.                 return "integer<i>";
  488.             else if (ival < INT_MIN) {
  489.                 PyErr_SetString(PyExc_OverflowError,
  490.                     "signed integer is less than minimum");
  491.                 return "integer<i>";
  492.             }
  493.             else if (ival > INT_MAX) {
  494.                 PyErr_SetString(PyExc_OverflowError,
  495.                   "signed integer is greater than maximum");
  496.                 return "integer<i>";
  497.             }
  498.             else
  499.                 *p = ival;
  500.             break;
  501.         }
  502.     
  503.     case 'l': /* long int */
  504.         {
  505.             long *p = va_arg(*p_va, long *);
  506.             long ival = PyInt_AsLong(arg);
  507.             if (ival == -1 && PyErr_Occurred())
  508.                 return "integer<l>";
  509.             else
  510.                 *p = ival;
  511.             break;
  512.         }
  513.     
  514. #ifdef HAVE_LONG_LONG
  515.     case 'L': /* LONG_LONG */
  516.         {
  517.             LONG_LONG *p = va_arg( *p_va, LONG_LONG * );
  518.             LONG_LONG ival = PyLong_AsLongLong( arg );
  519.             if( ival == (LONG_LONG)-1 && PyErr_Occurred() ) {
  520.                 return "long<L>";
  521.             } else {
  522.                 *p = ival;
  523.             }
  524.             break;
  525.         }
  526. #endif
  527.     
  528.     case 'f': /* float */
  529.         {
  530.             float *p = va_arg(*p_va, float *);
  531.             double dval = PyFloat_AsDouble(arg);
  532.             if (PyErr_Occurred())
  533.                 return "float<f>";
  534.             else
  535.                 *p = (float) dval;
  536.             break;
  537.         }
  538.     
  539.     case 'd': /* double */
  540.         {
  541.             double *p = va_arg(*p_va, double *);
  542.             double dval = PyFloat_AsDouble(arg);
  543.             if (PyErr_Occurred())
  544.                 return "float<d>";
  545.             else
  546.                 *p = dval;
  547.             break;
  548.         }
  549.     
  550. #ifndef WITHOUT_COMPLEX
  551.     case 'D': /* complex double */
  552.         {
  553.             Py_complex *p = va_arg(*p_va, Py_complex *);
  554.             Py_complex cval;
  555.             cval = PyComplex_AsCComplex(arg);
  556.             if (PyErr_Occurred())
  557.                 return "complex<D>";
  558.             else
  559.                 *p = cval;
  560.             break;
  561.         }
  562. #endif /* WITHOUT_COMPLEX */
  563.     
  564.     case 'c': /* char */
  565.         {
  566.             char *p = va_arg(*p_va, char *);
  567.             if (PyString_Check(arg) && PyString_Size(arg) == 1)
  568.                 *p = PyString_AsString(arg)[0];
  569.             else
  570.                 return "char";
  571.             break;
  572.         }
  573.     
  574.     case 's': /* string */
  575.         {
  576.             if (*format == '#') { /* any buffer-like object */
  577.                 void **p = (void **)va_arg(*p_va, char **);
  578.                 PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
  579.                 int *q = va_arg(*p_va, int *);
  580.                 int count;
  581.  
  582.                 if ( pb == NULL ||
  583.                      pb->bf_getreadbuffer == NULL ||
  584.                      pb->bf_getsegcount == NULL )
  585.                   return "read-only buffer";
  586.                 if ( (*pb->bf_getsegcount)(arg, NULL) != 1 )
  587.                   return "single-segment read-only buffer";
  588.                 if ( (count =
  589.                       (*pb->bf_getreadbuffer)(arg, 0, p)) < 0 )
  590.                   return "(unspecified)";
  591.                 *q = count;
  592.                 format++;
  593.             } else {
  594.                 char **p = va_arg(*p_va, char **);
  595.             
  596.                 if (PyString_Check(arg))
  597.                     *p = PyString_AS_STRING(arg);
  598.                 else if (PyUnicode_Check(arg)) {
  599.                     arg = _PyUnicode_AsDefaultEncodedString(
  600.                                         arg, NULL);
  601.                     if (arg == NULL)
  602.                     return "unicode conversion error";
  603.                     *p = PyString_AS_STRING(arg);
  604.                 }
  605.                 else
  606.                   return "string";
  607.                 if ((int)strlen(*p) != PyString_Size(arg))
  608.                   return "string without null bytes";
  609.             }
  610.             break;
  611.         }
  612.  
  613.     case 'z': /* string, may be NULL (None) */
  614.         {
  615.             if (*format == '#') { /* any buffer-like object */
  616.                 void **p = (void **)va_arg(*p_va, char **);
  617.                 PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
  618.                 int *q = va_arg(*p_va, int *);
  619.                 int count;
  620.  
  621.                 if (arg == Py_None) {
  622.                   *p = 0;
  623.                   *q = 0;
  624.                 } else {
  625.                   if ( pb == NULL ||
  626.                        pb->bf_getreadbuffer == NULL ||
  627.                        pb->bf_getsegcount == NULL )
  628.                     return "read-only buffer";
  629.                   if ( (*pb->bf_getsegcount)(arg, NULL) != 1 )
  630.                   return "single-segment read-only buffer";
  631.                   if ( (count = (*pb->bf_getreadbuffer)
  632.                                         (arg, 0, p)) < 0 )
  633.                     return "(unspecified)";
  634.                   *q = count;
  635.                 }
  636.                 format++;
  637.             } else {
  638.                 char **p = va_arg(*p_va, char **);
  639.             
  640.                 if (arg == Py_None)
  641.                   *p = 0;
  642.                 else if (PyString_Check(arg))
  643.                   *p = PyString_AsString(arg);
  644.                 else if (PyUnicode_Check(arg)) {
  645.                   arg = _PyUnicode_AsDefaultEncodedString(
  646.                                   arg, NULL);
  647.                   if (arg == NULL)
  648.                       return "unicode conversion error";
  649.                   *p = PyString_AS_STRING(arg);
  650.                 }
  651.                 else
  652.                   return "None or string";
  653.                 if (*format == '#') {
  654.                   int *q = va_arg(*p_va, int *);
  655.                   if (arg == Py_None)
  656.                     *q = 0;
  657.                   else
  658.                     *q = PyString_Size(arg);
  659.                   format++;
  660.                 }
  661.                 else if (*p != NULL &&
  662.                      (int)strlen(*p) != PyString_Size(arg))
  663.                   return "None or string without null bytes";
  664.             }
  665.             break;
  666.         }
  667.     
  668.     case 'e': /* encoded string */
  669.         {
  670.             char **buffer;
  671.             const char *encoding;
  672.             PyObject *u, *s;
  673.             int size;
  674.  
  675.             /* Get 'e' parameter: the encoding name */
  676.             encoding = (const char *)va_arg(*p_va, const char *);
  677.             if (encoding == NULL)
  678.                     encoding = PyUnicode_GetDefaultEncoding();
  679.             
  680.             /* Get 's' parameter: the output buffer to use */
  681.             if (*format != 's')
  682.                 return "(unknown parser marker combination)";
  683.             buffer = (char **)va_arg(*p_va, char **);
  684.             format++;
  685.             if (buffer == NULL)
  686.                 return "(buffer is NULL)";
  687.             
  688.             /* Convert object to Unicode */
  689.             u = PyUnicode_FromObject(arg);
  690.             if (u == NULL)
  691.                 return "string, unicode or text buffer";
  692.             
  693.             /* Encode object; use default error handling */
  694.             s = PyUnicode_AsEncodedString(u,
  695.                               encoding,
  696.                               NULL);
  697.             Py_DECREF(u);
  698.             if (s == NULL)
  699.                 return "(encoding failed)";
  700.             if (!PyString_Check(s)) {
  701.                 Py_DECREF(s);
  702.                 return "(encoder failed to return a string)";
  703.             }
  704.             size = PyString_GET_SIZE(s);
  705.  
  706.             /* Write output; output is guaranteed to be
  707.                0-terminated */
  708.             if (*format == '#') { 
  709.                 /* Using buffer length parameter '#':
  710.  
  711.                    - if *buffer is NULL, a new buffer
  712.                    of the needed size is allocated and
  713.                    the data copied into it; *buffer is
  714.                    updated to point to the new buffer;
  715.                    the caller is responsible for
  716.                    PyMem_Free()ing it after usage
  717.  
  718.                    - if *buffer is not NULL, the data
  719.                    is copied to *buffer; *buffer_len
  720.                    has to be set to the size of the
  721.                    buffer on input; buffer overflow is
  722.                    signalled with an error; buffer has
  723.                    to provide enough room for the
  724.                    encoded string plus the trailing
  725.                    0-byte
  726.  
  727.                    - in both cases, *buffer_len is
  728.                    updated to the size of the buffer
  729.                    /excluding/ the trailing 0-byte
  730.  
  731.                 */
  732.                 int *buffer_len = va_arg(*p_va, int *);
  733.  
  734.                 format++;
  735.                 if (buffer_len == NULL)
  736.                     return "(buffer_len is NULL)";
  737.                 if (*buffer == NULL) {
  738.                     *buffer = PyMem_NEW(char, size + 1);
  739.                     if (*buffer == NULL) {
  740.                         Py_DECREF(s);
  741.                         return "(memory error)";
  742.                     }
  743.                 } else {
  744.                     if (size + 1 > *buffer_len) {
  745.                         Py_DECREF(s);
  746.                         return "(buffer overflow)";
  747.                     }
  748.                 }
  749.                 memcpy(*buffer,
  750.                        PyString_AS_STRING(s),
  751.                        size + 1);
  752.                 *buffer_len = size;
  753.             } else {
  754.                 /* Using a 0-terminated buffer:
  755.  
  756.                    - the encoded string has to be
  757.                    0-terminated for this variant to
  758.                    work; if it is not, an error raised
  759.  
  760.                    - a new buffer of the needed size
  761.                    is allocated and the data copied
  762.                    into it; *buffer is updated to
  763.                    point to the new buffer; the caller
  764.                    is responsible for PyMem_Free()ing it
  765.                    after usage
  766.  
  767.                  */
  768.                 if ((int)strlen(PyString_AS_STRING(s)) != size)
  769.                     return "(encoded string without "\
  770.                            "NULL bytes)";
  771.                 *buffer = PyMem_NEW(char, size + 1);
  772.                 if (*buffer == NULL) {
  773.                     Py_DECREF(s);
  774.                     return "(memory error)";
  775.                 }
  776.                 memcpy(*buffer,
  777.                        PyString_AS_STRING(s),
  778.                        size + 1);
  779.             }
  780.             Py_DECREF(s);
  781.             break;
  782.         }
  783.  
  784.     case 'u': /* raw unicode buffer (Py_UNICODE *) */
  785.         {
  786.             if (*format == '#') { /* any buffer-like object */
  787.                 void **p = (void **)va_arg(*p_va, char **);
  788.                 PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
  789.                 int *q = va_arg(*p_va, int *);
  790.                 int count;
  791.  
  792.                 if ( pb == NULL ||
  793.                      pb->bf_getreadbuffer == NULL ||
  794.                      pb->bf_getsegcount == NULL )
  795.                   return "read-only buffer";
  796.                 if ( (*pb->bf_getsegcount)(arg, NULL) != 1 )
  797.                   return "single-segment read-only buffer";
  798.                 if ( (count =
  799.                       (*pb->bf_getreadbuffer)(arg, 0, p)) < 0 )
  800.                   return "(unspecified)";
  801.                 /* buffer interface returns bytes, we want
  802.                    length in characters */
  803.                 *q = count/(sizeof(Py_UNICODE)); 
  804.                 format++;
  805.             } else {
  806.                 Py_UNICODE **p = va_arg(*p_va, Py_UNICODE **);
  807.             
  808.                 if (PyUnicode_Check(arg))
  809.                     *p = PyUnicode_AS_UNICODE(arg);
  810.                 else
  811.                   return "unicode";
  812.             }
  813.             break;
  814.         }
  815.  
  816.     case 'S': /* string object */
  817.         {
  818.             PyObject **p = va_arg(*p_va, PyObject **);
  819.             if (PyString_Check(arg))
  820.                 *p = arg;
  821.             else
  822.                 return "string";
  823.             break;
  824.         }
  825.     
  826.     case 'U': /* Unicode object */
  827.         {
  828.             PyObject **p = va_arg(*p_va, PyObject **);
  829.             if (PyUnicode_Check(arg))
  830.                 *p = arg;
  831.             else
  832.                 return "unicode";
  833.             break;
  834.         }
  835.     
  836.     case 'O': /* object */
  837.         {
  838.             PyTypeObject *type;
  839.             PyObject **p;
  840.             if (*format == '!') {
  841.                 type = va_arg(*p_va, PyTypeObject*);
  842.                 p = va_arg(*p_va, PyObject **);
  843.                 format++;
  844.                 if (arg->ob_type == type)
  845.                     *p = arg;
  846.                 else
  847.                     return type->tp_name;
  848.  
  849.             }
  850.             else if (*format == '?') {
  851.                 inquiry pred = va_arg(*p_va, inquiry);
  852.                 p = va_arg(*p_va, PyObject **);
  853.                 format++;
  854.                 if ((*pred)(arg)) 
  855.                     *p = arg;
  856.                 else
  857.                     return "(unspecified)";
  858.                 
  859.             }
  860.             else if (*format == '&') {
  861.                 typedef int (*converter)
  862.                     Py_PROTO((PyObject *, void *));
  863.                 converter convert = va_arg(*p_va, converter);
  864.                 void *addr = va_arg(*p_va, void *);
  865.                 format++;
  866.                 if (! (*convert)(arg, addr))
  867.                     return "(unspecified)";
  868.             }
  869.             else {
  870.                 p = va_arg(*p_va, PyObject **);
  871.                 *p = arg;
  872.             }
  873.             break;
  874.         }
  875.         
  876.         
  877.     case 'w': /* memory buffer, read-write access */
  878.         {
  879.             void **p = va_arg(*p_va, void **);
  880.             PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
  881.             int count;
  882.             
  883.             if ( pb == NULL || pb->bf_getwritebuffer == NULL ||
  884.                     pb->bf_getsegcount == NULL )
  885.                 return "read-write buffer";
  886.             if ( (*pb->bf_getsegcount)(arg, NULL) != 1 )
  887.                 return "single-segment read-write buffer";
  888.             if ( (count = pb->bf_getwritebuffer(arg, 0, p)) < 0 )
  889.                 return "(unspecified)";
  890.             if (*format == '#') {
  891.                 int *q = va_arg(*p_va, int *);
  892.                 
  893.                 *q = count;
  894.                 format++;
  895.             }
  896.             break;
  897.         }
  898.         
  899.     case 't': /* 8-bit character buffer, read-only access */
  900.         {
  901.             const char **p = va_arg(*p_va, const char **);
  902.             PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
  903.             int count;
  904.  
  905.             if ( *format++ != '#' )
  906.                 return "invalid use of 't' format character";
  907.             if ( !PyType_HasFeature(
  908.                 arg->ob_type,
  909.                 Py_TPFLAGS_HAVE_GETCHARBUFFER) ||
  910.                  pb == NULL ||
  911.                  pb->bf_getcharbuffer == NULL ||
  912.                  pb->bf_getsegcount == NULL )
  913.                 return "read-only character buffer";
  914.             if ( (*pb->bf_getsegcount)(arg, NULL) != 1 )
  915.                 return "single-segment read-only buffer";
  916.             if ( (count = pb->bf_getcharbuffer(arg, 0, p)) < 0 )
  917.                 return "(unspecified)";
  918.  
  919.             *va_arg(*p_va, int *) = count;
  920.  
  921.             break;
  922.         }
  923.         
  924.     
  925.     default:
  926.         return "impossible<bad format char>";
  927.     
  928.     }
  929.     
  930.     *p_format = format;
  931.     return NULL;
  932. }
  933.  
  934.  
  935. /* Support for keyword arguments donated by
  936.    Geoff Philbrick <philbric@delphi.hks.com> */
  937.  
  938. #ifdef HAVE_STDARG_PROTOTYPES
  939. /* VARARGS2 */
  940. int PyArg_ParseTupleAndKeywords(PyObject *args,
  941.                 PyObject *keywords,
  942.                 char *format, 
  943.                 char **kwlist, ...)
  944. #else
  945. /* VARARGS */
  946. int PyArg_ParseTupleAndKeywords(va_alist) va_dcl
  947. #endif
  948. {
  949.     int retval;
  950.     va_list va;
  951. #ifdef HAVE_STDARG_PROTOTYPES
  952.     
  953.     va_start(va, kwlist);
  954. #else
  955.     PyObject *args;
  956.     PyObject *keywords;
  957.     char *format;
  958.     char **kwlist;
  959.     
  960.     va_start(va);
  961.     args = va_arg(va, PyObject *);
  962.     keywords = va_arg(va, PyObject *);
  963.     format = va_arg(va, char *);
  964.     kwlist = va_arg(va, char **);
  965. #endif
  966.     retval = vgetargskeywords(args, keywords, format, kwlist, &va);    
  967.     va_end(va);
  968.     return retval;
  969. }
  970.  
  971.  
  972. static int
  973. vgetargskeywords(args, keywords, format, kwlist, p_va)
  974.     PyObject *args;
  975.     PyObject *keywords;
  976.     char *format;
  977.     char **kwlist;
  978.     va_list *p_va;
  979. {
  980.     char msgbuf[256];
  981.     int levels[32];
  982.     char *fname = NULL;
  983.     char *message = NULL;
  984.     int min = -1;
  985.     int max = 0;
  986.     char *formatsave = format;
  987.     int i, len, tplen, kwlen;
  988.     char *msg, *ks, **p;
  989.     int nkwds, pos, match, converted;
  990.     PyObject *key, *value;
  991.     
  992.     /* nested tuples cannot be parsed when using keyword arguments */
  993.     
  994.     for (;;) {
  995.         int c = *format++;
  996.         if (c == '(') {
  997.             PyErr_SetString(PyExc_SystemError,
  998.               "tuple found in format when using keyword arguments");
  999.             return 0;
  1000.         }
  1001.         else if (c == '\0')
  1002.             break;
  1003.         else if (c == ':') {
  1004.             fname = format;
  1005.             break;
  1006.         }
  1007.         else if (c == ';') {
  1008.             message = format;
  1009.             break;
  1010.         }
  1011.         else if (isalpha(c))
  1012.             max++;
  1013.         else if (c == '|')
  1014.             min = max;
  1015.     }    
  1016.     
  1017.     if (min < 0)
  1018.         min = max;
  1019.     
  1020.     format = formatsave;
  1021.     
  1022.     if (!PyTuple_Check(args)) {
  1023.         PyErr_SetString(PyExc_SystemError,
  1024.             "new style getargs format but argument is not a tuple");
  1025.         return 0;
  1026.     }    
  1027.     
  1028.     tplen = PyTuple_Size(args);
  1029.     
  1030.     /* do a cursory check of the keywords just to see how many we got */
  1031.        
  1032.     if (keywords) {     
  1033.         if (!PyDict_Check(keywords)) {
  1034.             PyErr_SetString(PyExc_SystemError,
  1035.       "non-dictionary object received when keyword dictionary expected");
  1036.             return 0;
  1037.         }    
  1038.         kwlen = PyDict_Size(keywords);
  1039.     }
  1040.     else {
  1041.         kwlen = 0;
  1042.     }
  1043.             
  1044.     /* make sure there are no duplicate values for an argument;
  1045.        its not clear when to use the term "keyword argument vs. 
  1046.        keyword parameter in messages */
  1047.     
  1048.     if (keywords) {
  1049.         for (i = 0; i < tplen; i++) {
  1050.             if (PyMapping_HasKeyString(keywords, kwlist[i])) {
  1051.                 sprintf(msgbuf,
  1052.                     "keyword parameter %s redefined",
  1053.                     kwlist[i]);
  1054.                 PyErr_SetString(PyExc_TypeError, msgbuf);
  1055.                 return 0;
  1056.             }
  1057.         }
  1058.     }
  1059.     PyErr_Clear(); /* I'm not which Py functions set the error string */
  1060.         
  1061.     /* required arguments missing from args can be supplied by keyword 
  1062.        arguments */
  1063.     
  1064.     len = tplen;
  1065.     if (keywords && tplen < min) {
  1066.         for (i = tplen; i < min; i++) {
  1067.           if (PyMapping_HasKeyString(keywords, kwlist[i])) {
  1068.                 len++;
  1069.           }
  1070.         }
  1071.     }
  1072.     PyErr_Clear();    
  1073.     
  1074.     /* make sure we got an acceptable number of arguments; the message
  1075.        is a little confusing with keywords since keyword arguments
  1076.        which are supplied, but don't match the required arguments
  1077.        are not included in the "%d given" part of the message */
  1078.  
  1079.     if (len < min || max < len) {
  1080.         if (message == NULL) {
  1081.             sprintf(msgbuf,
  1082.                 "%s requires %s %d argument%s; %d given",
  1083.                 fname==NULL ? "function" : fname,
  1084.                 min==max ? "exactly"
  1085.                          : len < min ? "at least" : "at most",
  1086.                 len < min ? min : max,
  1087.                 (len < min ? min : max) == 1 ? "" : "s",
  1088.                 len);
  1089.             message = msgbuf;
  1090.         }
  1091.         PyErr_SetString(PyExc_TypeError, message);
  1092.         return 0;
  1093.     }
  1094.     
  1095.     for (i = 0; i < tplen; i++) {
  1096.         if (*format == '|')
  1097.             format++;
  1098.         msg = convertitem(PyTuple_GetItem(args, i), &format, p_va,
  1099.                  levels, msgbuf);
  1100.         if (msg) {
  1101.             seterror(i+1, msg, levels, fname, message);
  1102.             return 0;
  1103.         }
  1104.     }
  1105.  
  1106.     /* handle no keyword parameters in call  */    
  1107.               
  1108.     if (!keywords) return 1; 
  1109.         
  1110.     /* make sure the number of keywords in the keyword list matches the 
  1111.        number of items in the format string */
  1112.       
  1113.     nkwds = 0;
  1114.     p =  kwlist;
  1115.     for (;;) {
  1116.         if (!*(p++)) break;
  1117.         nkwds++;
  1118.     }
  1119.  
  1120.     if (nkwds != max) {
  1121.         PyErr_SetString(PyExc_SystemError,
  1122.       "number of items in format string and keyword list do not match");
  1123.         return 0;
  1124.     }            
  1125.             
  1126.     /* convert the keyword arguments; this uses the format 
  1127.        string where it was left after processing args */
  1128.     
  1129.     converted = 0;
  1130.     for (i = tplen; i < nkwds; i++) {
  1131.         PyObject *item;
  1132.         if (*format == '|')
  1133.             format++;
  1134.         item = PyMapping_GetItemString(keywords, kwlist[i]);
  1135.         if (item != NULL) {
  1136.             msg = convertitem(item, &format, p_va, levels, msgbuf);
  1137.             if (msg) {
  1138.                 seterror(i+1, msg, levels, fname, message);
  1139.                 return 0;
  1140.             }
  1141.             converted++;
  1142.         }
  1143.         else {
  1144.             PyErr_Clear();
  1145.             msg = skipitem(&format, p_va);
  1146.             if (msg) {
  1147.                 seterror(i+1, msg, levels, fname, message);
  1148.                 return 0;
  1149.             }
  1150.         }
  1151.     }
  1152.     
  1153.     /* make sure there are no extraneous keyword arguments */
  1154.     
  1155.     pos = 0;
  1156.     if (converted < kwlen) {
  1157.         while (PyDict_Next(keywords, &pos, &key, &value)) {
  1158.             match = 0;
  1159.             ks = PyString_AsString(key);
  1160.             for (i = 0; i < nkwds; i++) {
  1161.                 if (!strcmp(ks, kwlist[i])) {
  1162.                     match = 1;
  1163.                     break;
  1164.                 }
  1165.             }
  1166.             if (!match) {
  1167.                 sprintf(msgbuf,
  1168.             "%s is an invalid keyword argument for this function",
  1169.                     ks);
  1170.                 PyErr_SetString(PyExc_TypeError, msgbuf);
  1171.                 return 0;
  1172.             }
  1173.         }
  1174.     }
  1175.     
  1176.     return 1;
  1177. }
  1178.  
  1179.  
  1180. static char *
  1181. skipitem(p_format, p_va)
  1182.     char **p_format;
  1183.     va_list *p_va;
  1184. {
  1185.     char *format = *p_format;
  1186.     char c = *format++;
  1187.     
  1188.     switch (c) {
  1189.     
  1190.     case 'b': /* byte -- very short int */
  1191.         {
  1192.             (void) va_arg(*p_va, char *);
  1193.             break;
  1194.         }
  1195.     
  1196.     case 'h': /* short int */
  1197.         {
  1198.             (void) va_arg(*p_va, short *);
  1199.             break;
  1200.         }
  1201.     
  1202.     case 'i': /* int */
  1203.         {
  1204.             (void) va_arg(*p_va, int *);
  1205.             break;
  1206.         }
  1207.     
  1208.     case 'l': /* long int */
  1209.         {
  1210.             (void) va_arg(*p_va, long *);
  1211.             break;
  1212.         }
  1213.     
  1214. #ifdef HAVE_LONG_LONG
  1215.     case 'L': /* LONG_LONG int */
  1216.         {
  1217.             (void) va_arg(*p_va, LONG_LONG *);
  1218.             break;
  1219.         }
  1220. #endif
  1221.     
  1222.     case 'f': /* float */
  1223.         {
  1224.             (void) va_arg(*p_va, float *);
  1225.             break;
  1226.         }
  1227.     
  1228.     case 'd': /* double */
  1229.         {
  1230.             (void) va_arg(*p_va, double *);
  1231.             break;
  1232.         }
  1233.     
  1234. #ifndef WITHOUT_COMPLEX
  1235.     case 'D': /* complex double */
  1236.         {
  1237.             (void) va_arg(*p_va, Py_complex *);
  1238.             break;
  1239.         }
  1240. #endif /* WITHOUT_COMPLEX */
  1241.     
  1242.     case 'c': /* char */
  1243.         {
  1244.             (void) va_arg(*p_va, char *);
  1245.             break;
  1246.         }
  1247.     
  1248.     case 's': /* string */
  1249.         {
  1250.             (void) va_arg(*p_va, char **);
  1251.             if (*format == '#') {
  1252.                 (void) va_arg(*p_va, int *);
  1253.                 format++;
  1254.             }
  1255.             break;
  1256.         }
  1257.     
  1258.     case 'z': /* string */
  1259.         {
  1260.             (void) va_arg(*p_va, char **);
  1261.             if (*format == '#') {
  1262.                 (void) va_arg(*p_va, int *);
  1263.                 format++;
  1264.             }
  1265.             break;
  1266.         }
  1267.     
  1268.     case 'S': /* string object */
  1269.         {
  1270.             (void) va_arg(*p_va, PyObject **);
  1271.             break;
  1272.         }
  1273.     
  1274.     case 'O': /* object */
  1275.         {
  1276.             if (*format == '!') {
  1277.                 format++;
  1278.                 (void) va_arg(*p_va, PyTypeObject*);
  1279.                 (void) va_arg(*p_va, PyObject **);
  1280.             }
  1281. #if 0
  1282. /* I don't know what this is for */
  1283.             else if (*format == '?') {
  1284.                 inquiry pred = va_arg(*p_va, inquiry);
  1285.                 format++;
  1286.                 if ((*pred)(arg)) {
  1287.                     (void) va_arg(*p_va, PyObject **);
  1288.                 }
  1289.             }
  1290. #endif
  1291.             else if (*format == '&') {
  1292.                 typedef int (*converter)
  1293.                     Py_PROTO((PyObject *, void *));
  1294.                 (void) va_arg(*p_va, converter);
  1295.                 (void) va_arg(*p_va, void *);
  1296.                 format++;
  1297.             }
  1298.             else {
  1299.                 (void) va_arg(*p_va, PyObject **);
  1300.             }
  1301.             break;
  1302.         }
  1303.     
  1304.     default:
  1305.         return "impossible<bad format char>";
  1306.     
  1307.     }
  1308.     
  1309.     *p_format = format;
  1310.     return NULL;
  1311. }
  1312.